{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "DeepONet_DR.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "nY1RmvevXrp9"
   },
   "source": [
    "import jax\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit, hessian, lax\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.nn import relu\n",
    "from jax.config import config\n",
    "from jax.ops import index_update, index\n",
    "from jax.flatten_util import ravel_pytree\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange, tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.interpolate import griddata\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ikWFHV5IX5lh"
   },
   "source": [
    "# Data generator\n",
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u # input sample\n",
    "        self.y = y # location\n",
    "        self.s = s # labeled data evulated at y (solution measurements, BC/IC conditions, etc.)\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "R4tCyvLs7luG"
   },
   "source": [
    "# Define the neural net\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "4ckGVVDAYCB7"
   },
   "source": [
    "# Define the model\n",
    "class DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=np.tanh)  # or Relu \n",
    "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=np.tanh)     # or Relu\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=2000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        # Used to restore the trained model parameters\n",
    "        _, self.unravel_params = ravel_pytree(params)\n",
    "\n",
    "        self.itercount = itertools.count()\n",
    "\n",
    "        # Loggers\n",
    "        self.loss_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, x, t):\n",
    "        branch_params, trunk_params = params\n",
    "        y = np.stack([x, t])\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return  outputs\n",
    "  \n",
    "    # Define operator loss\n",
    "    def loss_operator(self, params, batch):\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - s_pred.flatten())**2)\n",
    "        return loss\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss_operator)(params, batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, dataset, nIter = 10000):\n",
    "        # Define data iterators\n",
    "        data_iterator = iter(dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            # Fetch data\n",
    "            batch = next(data_iterator)\n",
    "           \n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute loss\n",
    "                loss_value = self.loss_operator(params, batch)\n",
    "\n",
    "                # Store loss\n",
    "                self.loss_log.append(loss_value)\n",
    "  \n",
    "                # Print loss\n",
    "                pbar.set_postfix({'Loss': loss_value})\n",
    "           \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return s_pred"
   ],
   "execution_count": 4,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "EyGqzSnIv211"
   },
   "source": [
    "# Use double precision to generate data (due to GP sampling)\n",
    "def RBF(x1, x2, params):\n",
    "    output_scale, lengthscales = params\n",
    "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
    "            np.expand_dims(x2 / lengthscales, 0)\n",
    "    r2 = np.sum(diffs**2, axis=2)\n",
    "    return output_scale * np.exp(-0.5 * r2)\n",
    "\n",
    "# A diffusion-reaction numerical solver\n",
    "def solve_ADR(key, Nx, Nt, P, length_scale):\n",
    "    \"\"\"Solve 1D\n",
    "    u_t = (k(x) u_x)_x - v(x) u_x + g(u) + f(x)\n",
    "    with zero initial and boundary conditions.\n",
    "    \"\"\"\n",
    "    xmin, xmax = 0, 1\n",
    "    tmin, tmax = 0, 1\n",
    "    k = lambda x: 0.01*np.ones_like(x)\n",
    "    v = lambda x: np.zeros_like(x)\n",
    "    g = lambda u: 0.01*u ** 2\n",
    "    dg = lambda u: 0.02 * u\n",
    "    u0 = lambda x: np.zeros_like(x)\n",
    "\n",
    "    # Generate subkeys\n",
    "    subkeys = random.split(key, 2)\n",
    "\n",
    "    # Generate a GP sample\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(xmin, xmax, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(subkeys[0], (N,)))\n",
    "    # Create a callable interpolation function  \n",
    "    f_fn = lambda x: np.interp(x, X.flatten(), gp_sample)\n",
    "\n",
    "    # Create grid\n",
    "    x = np.linspace(xmin, xmax, Nx)\n",
    "    t = np.linspace(tmin, tmax, Nt)\n",
    "    h = x[1] - x[0]\n",
    "    dt = t[1] - t[0]\n",
    "    h2 = h ** 2\n",
    "\n",
    "    # Compute coefficients and forcing\n",
    "    k = k(x)\n",
    "    v = v(x)\n",
    "    f = f_fn(x)\n",
    "\n",
    "    # Compute finite difference operators\n",
    "    D1 = np.eye(Nx, k=1) - np.eye(Nx, k=-1)\n",
    "    D2 = -2 * np.eye(Nx) + np.eye(Nx, k=-1) + np.eye(Nx, k=1)\n",
    "    D3 = np.eye(Nx - 2)\n",
    "    M = -np.diag(D1 @ k) @ D1 - 4 * np.diag(k) @ D2\n",
    "    m_bond = 8 * h2 / dt * D3 + M[1:-1, 1:-1]\n",
    "    v_bond = 2 * h * np.diag(v[1:-1]) @ D1[1:-1, 1:-1] + 2 * h * np.diag(\n",
    "        v[2:] - v[: Nx - 2]\n",
    "    )\n",
    "    mv_bond = m_bond + v_bond\n",
    "    c = 8 * h2 / dt * D3 - M[1:-1, 1:-1] - v_bond\n",
    "\n",
    "    # Initialize solution and apply initial condition\n",
    "    u = np.zeros((Nx, Nt))\n",
    "    u = index_update(u, index[:,0], u0(x))\n",
    "    # Time-stepping update\n",
    "    def body_fn(i, u):\n",
    "        gi = g(u[1:-1, i])\n",
    "        dgi = dg(u[1:-1, i])\n",
    "        h2dgi = np.diag(4 * h2 * dgi)\n",
    "        A = mv_bond - h2dgi\n",
    "        b1 = 8 * h2 * (0.5 * f[1:-1] + 0.5 * f[1:-1] + gi)\n",
    "        b2 = (c - h2dgi) @ u[1:-1, i].T\n",
    "        u = index_update(u, index[1:-1, i + 1], np.linalg.solve(A, b1 + b2))\n",
    "        return u\n",
    "    # Run loop\n",
    "    UU = lax.fori_loop(0, Nt-1, body_fn, u)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    xx = np.linspace(xmin, xmax, m)\n",
    "    u = f_fn(xx)\n",
    "    # Output sensor locations and measurements\n",
    "    idx = random.randint(subkeys[1], (P, 2), 0, max(Nx, Nt))\n",
    "    y = np.concatenate([x[idx[:,0]][:,None], t[idx[:,1]][:,None]], axis = 1)\n",
    "    s = UU[idx[:,0], idx[:,1]]\n",
    "    # x, t: sampled points on grid\n",
    "    return (x, t, UU), (u, y, s)\n",
    "\n",
    "# Geneate training data corresponding to one input sample\n",
    "def generate_one_training_data(key, P):\n",
    "    # Numerical solution\n",
    "    (x, t, UU), (u, y, s) = solve_ADR(key, Nx , Nt, P, length_scale)\n",
    "\n",
    "    u = np.tile(u, (P, 1))\n",
    "\n",
    "    return u, y, s\n",
    "\n",
    "# Geneate test data corresponding to one input sample\n",
    "def generate_one_test_data(key, P):\n",
    "    Nx = P\n",
    "    Nt = P\n",
    "    (x, t, UU), (u, y, s) = solve_ADR(key, Nx , Nt, P, length_scale)\n",
    "\n",
    "    XX, TT = np.meshgrid(x, t)\n",
    "\n",
    "    u_test = np.tile(u, (P**2, 1))\n",
    "    y_test = np.hstack([XX.flatten()[:,None], TT.flatten()[:,None]])\n",
    "    s_test = UU.T.flatten()\n",
    "\n",
    "    return u_test, y_test, s_test\n",
    "\n",
    "# Geneate training data corresponding to N input sample\n",
    "def generate_training_data(key, N, P):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    u_train, y_train, s_train= vmap(generate_one_training_data, (0, None))(keys, P)\n",
    "\n",
    "    u_train = np.float32(u_train.reshape(N * P, -1))\n",
    "    y_train = np.float32(y_train.reshape(N * P, -1))\n",
    "    s_train = np.float32(s_train.reshape(N * P, -1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_train, y_train, s_train\n",
    "\n",
    "# Geneate test data corresponding to N input sample\n",
    "def generate_test_data(key, N, P):\n",
    "\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "\n",
    "    u_test, y_test, s_test = vmap(generate_one_test_data, (0, None))(keys, P)\n",
    "\n",
    "    u_test = np.float32(u_test.reshape(N * P**2, -1))\n",
    "    y_test = np.float32(y_test.reshape(N * P**2, -1))\n",
    "    s_test = np.float32(s_test.reshape(N * P**2, -1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_test, y_test, s_test\n",
    "\n",
    "# Compute relative l2 error over N test samples.\n",
    "def compute_error(key, P):\n",
    "    # Generate one test sample\n",
    "    u_test, y_test, s_test = generate_test_data(key, 1, P)\n",
    "    # Predict  \n",
    "    s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "    # Compute relative l2 error\n",
    "    error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
    "    return error_s"
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "s4o8uU971yfJ"
   },
   "source": [
    "key = random.PRNGKey(0)\n",
    "\n",
    "# GRF length scale\n",
    "length_scale = 0.2\n",
    "\n",
    "# Resolution of the solution\n",
    "Nx = 100\n",
    "Nt = 100\n",
    "\n",
    "N = 5000 # number of input samples\n",
    "m = Nx   # number of input sensors\n",
    "P_train = 100 # number of output sensors\n",
    "\n",
    "u_train, y_train, s_train = generate_training_data(key, N, P_train)"
   ],
   "execution_count": 6,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZdbEC_IV5d8r"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [m, 50, 50, 50, 50, 50]\n",
    "trunk_layers =  [2, 50, 50, 50, 50, 50]\n",
    "model = DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "FDVeE-dk6I35"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "dataset = DataGenerator(u_train, y_train, s_train, batch_size)"
   ],
   "execution_count": 8,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RYb9vB0h7Kzl",
    "outputId": "68dbc426-ea4e-4dc4-f508-2cddd311ad03"
   },
   "source": [
    "# Train\n",
    "model.train(dataset, nIter=120000)\n"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "100%|██████████| 120000/120000 [11:05<00:00, 180.26it/s, Loss=1.5141619e-05]\n"
     ],
     "name": "stderr"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cN2my_9hfe4e",
    "outputId": "d6ab88da-0db6-4a4a-88e3-83dab136b3d7"
   },
   "source": [
    "# Test data\n",
    "N_test = 100 # number of input samples \n",
    "P_test = m   # number of sensors \n",
    "key_test = random.PRNGKey(1234567)\n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "# Predict\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Compute error\n",
    "error_s = vmap(compute_error, (0, None))(keys_test,P_test) \n",
    "\n",
    "print('mean of relative L2 error of s: {:.2e}'.format(error_s.mean()))\n",
    "print('std of relative L2 error of s: {:.2e}'.format(error_s.std()))"
   ],
   "execution_count": 10,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "mean of relative L2 error of s: 9.71e-03\n",
      "std of relative L2 error of s: 5.25e-03\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 386
    },
    "id": "E1M0cRJzt2yK",
    "outputId": "4600ec8c-bdcd-4794-ae1a-84c11e8a1e8c"
   },
   "source": [
    "#Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "plt.plot(model.loss_log, lw=2)\n",
    "\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 11,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n"
     ],
     "name": "stderr"
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAFgCAYAAADuCe0ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU9b3/8dcnk40kEEhYZA+bCLg3oLhV6oYL6u1yC/ZWr1rRttpr/d1ard1se4vdvNeqrVJL1brVamvdEFfABRBwQWQNexAIBAhhyTrf3x8zCVkmyYTM5MycvJ+PRx7M+Z5lvoeBeed7zvd8v+acQ0REJNGkeF0BERGRSBRQIiKSkBRQIiKSkBRQIiKSkBRQIiKSkFK9rkA89O7d2xUUFHhdDRERicLSpUt3Oef6NC33ZUAVFBSwZMkSr6shIiJRMLNNkcp1iU9ERBKSrwLKzKaY2cyysjKvqyIiIh3kq4Byzr3gnJuem5vrdVVERKSDfHkPSkREvFFdXU1xcTEVFRXN1mVmZjJo0CDS0tKiOpYCSkREYqa4uJju3btTUFCAmdWXO+coLS2luLiYYcOGRXUsX13iExERb1VUVJCfn98onADMjPz8/Igtq5YooEREJKaahlNb5S1RQImISEJSQImISEJSQImISEy1NBFueyfIVUCJiEjMZGZmUlpa2iyM6nrxZWZmRn0sdTNvYvYn23ht5Q4uPLY/543t53V1RESSyqBBgyguLmbnzp3N1tU9BxUtBVQTK7bt4x8fbKUgP1sBJSLSTmlpaVE/59QWXeJrIpAS6gZZE2zftVIREYktBVQTqeGAqg0GPa6JiEjXpoBqIpAS+itRC0pExFsKqCYC4b+R2loFlIiIlxRQTagFJSKSGBRQTRy+B6WAEhHxUsIHlJkNN7M/m9kznfF+db34atv5xLOIiMRWXAPKzGaZWYmZLW9SPtnMVptZkZnd1toxnHPrnXPXxrOeDdW3oHQPSkTEU/F+UPdh4D7g0boCMwsA9wPnAcXAYjN7HggAM5rsf41zriTOdWxEz0GJiCSGuAaUc26+mRU0KZ4AFDnn1gOY2VPAZc65GcAl8axPNFIDeg5KRCQReHEPaiCwpcFycbgsIjPLN7MHgJPM7PZWtptuZkvMbEmkMaCipV58IiKJIeHH4nPOlQI3RLHdTGAmQGFh4RGni3rxiYgkBi9aUFuBwQ2WB4XLEoLuQYmIJAYvAmoxMMrMhplZOjAVeD4WBzazKWY2s6ys7IiPoRaUiEhiiHc38yeBBcBoMys2s2udczXAjcAcYCXwtHPu01i8n3PuBefc9Nzc3CM+hlpQIiKJId69+Ka1UP4y8HI83/tIBTSauYhIQkj4kSTaIxaX+OpbUHpQV0TEU74KqFhc4ksNdzPXPSgREW/5KqBiQfegREQSgwKqCfXiExFJDL4KqFjeg1JAiYh4y1cBFZN7UAEFlIhIIvBVQMVCav09KHUzFxHxkgKqiYB68YmIJAQFVBOp6sUnIpIQfBVQ6iQhIuIfvgqo2DyoqxaUiEgi8FVAxYJaUCIiiUEB1cThsfjUi09ExEsKqCbUghIRSQwKqCbqBovVPSgREW/5KqDUi09ExD98FVDqxSci4h++CqhYSEkxLJRRBBVSIiKeUUBFoFaUiIj3FFARpAdCfy0VNbUe10REpOtSQEXQMysdgD0HqjyuiYhI1+WrgIpFLz6A3jmhgCpVQImIeMZXARWLXnwAedmhgNq9XwElIuIVXwVUrGSkBgCo0nBHIiKeUUBFENC07yIinlNARRAwBZSIiNcUUBHoOSgREe8poCKoG49PI0mIiHhHARVBQC0oERHPKaAiqB/R3CmgRES84quAitWDuvUBpW7mIiKe8VVAxepBXV3iExHxnq8CKlbqevEFdYlPRMQzCqgIUtSCEhHxnAIqgtT6e1AKKBERryigIqgfSUKX+EREPKOAiiCQEvpr0VBHIiLeUUBFkKrBYkVEPKeAiiBFg8WKiHhOARWBBosVEfGeAiqC+pEkFFAiIp5RQEWggBIR8Z4CKoK6ThLVGotPRMQzvgqoWA0Wm5UeAOBgVW0sqiUiIkfAVwEVq8Fis9JTAQWUiIiXfBVQsVLXgjpUXeNxTUREui4FVAR1AXWgUi0oERGvKKAiqLvEd0iX+EREPKOAiqC+BVWlS3wiIl5RQEWgFpSIiPcUUBGom7mIiPcUUBF0S6vrxVdLUKNJiIh4QgEVQUqKNQopERHpfAqoFqijhIiItxRQLehW97Cu7kOJiHhCAdWCbA13JCLiKQVUC7rV9+TTJT4RES8ooFqQnaGu5iIiXlJAtaBbWugSn8bjExHxhgKqBRrRXETEW6leVyAaZnY5cDHQA/izc+7VeL+nLvGJiHgr7i0oM5tlZiVmtrxJ+WQzW21mRWZ2W2vHcM4955y7DrgB+Go861un7hLfQV3iExHxRGe0oB4G7gMerSswswBwP3AeUAwsNrPngQAwo8n+1zjnSsKvfxjeL+7UghIR8VbcA8o5N9/MCpoUTwCKnHPrAczsKeAy59wM4JKmxzAzA+4CZjvnPohvjUPqu5nrHpSIiCe86iQxENjSYLk4XNaSm4BzgS+b2Q2RNjCz6Wa2xMyW7Ny5s8MVzAqPxadLfCIi3kiKXnzOud875z7nnLvBOfdAC9vMdM4VOucK+/Tp0+H3rJsT6q8LN3X4WCIi0n5eBdRWYHCD5UHhsoRRUl5R/7qqJuhhTUREuiavAmoxMMrMhplZOjAVeL6jBzWzKWY2s6ysrMMVvOi4/vWv9xys6vDxRESkfTqjm/mTwAJgtJkVm9m1zrka4EZgDrASeNo592lH38s594Jzbnpubm5HD8XwPjkMzusGwK79lR0+noiItE9n9OKb1kL5y8DL8X7/jhiSl8WW3Yco3a8WlIhIZ0uKThJeyc/OAKD0gFpQIiKdzVcBFct7UAD5OekAzF+zKybHExGR6PkqoGJ5Dwqgd06oBfXPD7eyr6I6JscUEZHo+CqgYq1H5uFbdLoPJSLSuRRQrThnTL/612WH1IISEelMvgqoWN+DGtCzG8cNDF0u3KtnoUREOpWvAirW96AAhuZnAWpBiYh0Nl8FVDx0z9TU7yIiXlBAtaFu0NiDVZp2Q0SkM/kqoGJ9DwogKzwv1PpdB/hs76GYHVdERFrnq4CKxz2ouhbUE4s2c9pdb1IbdDE7toiItMxXARUPdVO/16mo1r0oEZHOoIBqQ263tEbLCigRkc6hgGrDxOH5jZYrNHmhiEinUEC1oW48vjqHqtSCEhHpDL4KqHj04ktJsUbLusQnItI5fBVQ8ejF15QCSkSkc/gqoDpDeaUe2BUR6QwKqHa6+i+L2bjrgNfVEBHxPQXUETj7t3N5Zfl2r6shIuJrCqgo3DvtpGZl33x8qQc1ERHpOhRQUZhywgAW33Fuo7JuaYEWthYRkVjwVUDFo5t5nT7dGz8PdVDPQ4mIxJWvAire3cy/dPKgRsvvFu3i/reK2LW/Mi7vJyLSlfkqoOLtK4WNA+prDy3iN3NWU/iL15kxe6VHtRIR8ScFVDucOjyfb08aEXHdg/PWd3JtRET8TQHVToN6ZXldBRGRLkEB1U5TThjgdRVERLoEBVQ75WSktrp+zY5yHlu4iaBm3hUR6ZDWv22lXe59Yy2/e20NAHnZ6Vx0XH+PayQikrx81YKK53NQDc25+ayI5XXhBLBB4/WJiHSIrwKqM6bbABh9VHd+cfmxrW4TaDKPlIiItI8u8R2hqeMHc6CyhqH52dzwWPNx+VIVUCIiHeKrFlRnSg2kcP3nR3D8oMittUgB9fqKHZx+15ssK94b7+qJiCQ9BVQHZbYwaGwg0Pyv9huPLmHr3kPc9OSH8a6WiEjSU0B1UF52esTytFYu8QWduqCLiLRFARUDw3pnNytTBImIdIwCKgYi9dirqQ16UBMREf9QQMXAGSN7Nyurqm25DWWoh5+ISFsUUDFw1WkF9M5pfC+qpjbIK8u3s3XvIY9qJSKS3PQcVAwM653Nb758Alc/vLi+bMbsVQCkB1JY8z8XelU1EZGkpRZUjFgLV+2qItyLamlbERE5TAEVI4PzNE+UiEgs+SqgOmuw2EhG9MnhT1cW8tCVhc3W1TaZekMNKBGRtvkqoDprsNiWnDe2H+eO7ccNn288Lfz3nvmYWe9s8KROIiLJKqqAMrNsM0sJvz7azC41s7T4Vi153XbhMY2W//HBVn724gqPaiMikpyibUHNBzLNbCDwKvB14OF4VcoPurUwRh9A8Z5DfFLc+ZchRUSSSbQBZc65g8AXgT84574CjItftZLf09dPbHFdTdAx5b532Fle2Yk1EhFJLlEHlJlNBL4GvBQua7mJIBw3KJd/fOu0Vrf5TA/xioi0KNqAuhm4Hfinc+5TMxsOvBW/avnDCYN6Mrpf9xbX12pUcxGRFkUVUM65ec65S51zvwp3ltjlnPtOnOuW9AIpxiPXTGhxfTCogBIRaUm0vfieMLMeZpYNLAdWmNn34ls1f8jPSSc7PfLV0KbPR4mIyGHRXuIb65zbB1wOzAaGEerJJ21IC6Tw7m1f4OQhPZutU0CJiLQs2oBKCz/3dDnwvHOuGs3JF7WeWemkpzb/q65RQImItCjagHoQ2AhkA/PNbCiwL16V8qNbzhvdrKyqRpMaioi0JNpOEr93zg10zl3kQjYBk+JcN1+ZMCyvWdmvXlnlQU1ERJJDtJ0kcs3sbjNbEv75HaHWlLTDvdNOarS8tmS/RzUREUl80V7imwWUA/8e/tkH/CVelfKr1oY/EhGRxqKdUXeEc+5LDZbvNLOP4lEhP8tI89Xg8SIicRXtN+YhMzujbsHMTgc0Tk87jerbfFQJp9EkREQiirYFdQPwqJnVTbS0B7gqPlXyr349MpqVLdqwm1OH53tQGxGRxBZtL76PnXMnAMcDxzvnTgK+ENeahZnZGDN7wMyeMbNvdsZ7xotZ87l0r5z1vgc1ERFJfO26KeKc2xceUQLglra2N7NZZlZiZsublE82s9VmVmRmt7XxniudczcQ6pxxenvqm4i+c86oRstVNUEqqmv1TJSISBMduWvfvDnQ3MPA5EY7mQWA+4ELgbHANDMba2bHmdmLTX76hve5lNA0Hy93oL4JoX9uZrOy4+98lUm/ndv5lRERSWDR3oOKpM27+865+WZW0KR4AlDknFsPYGZPAZc552YAl7RwnOeB583sJeCJSNuY2XRgOsCQIUOiPIXONzQvq1lZVU2QrZobSkSkkVYDyszKiRxEBnQ7wvccCGxpsFwMnNJKHc4mNJNvBq20oJxzM4GZAIWFhQnbNW7iiJY7RDjnIt6nEhHpiloNKOdcy7PtdRLn3FxgrsfViBkz44lvnMIVDy1qtq426EgNKKBERKBj96CO1FZgcIPlQeGyDjOzKWY2s6ysLBaHi5vTRvaOWK7RzUVEDvMioBYDo8xsmJmlA1OB52NxYOfcC8656bm5uW1vnIAUUCIih8U1oMzsSWABMNrMis3sWudcDXAjMAdYCTztnPs0nvVIFjW16mouIlKnI7342uScm9ZC+cv4oMt4R1x/1nAenL++UVl1rVpQIiJ1fDV6abLcgwK4qckDu6Ap4EVEGvJVQCXTPajs9OZTb1TrEp+ISD1fBVQyMTOevO7URmXqJCEicpgCykNNH9qtDaoFJSJSx1cBlUz3oCLZV1EDwJbdB3lg3joOVNZ4XCMREe/4KqCS6R5UJF/8w3v8/o21fPmB97hr9ip+M2e111USEfGMrwLKD+5+bQ079lUC8OwHxZSUV3hcIxERbyigPPbSd85ocV15RQ2TfjNXvftEpEvyVUAl4z2ocQNySWllfNgDVbW6FyUiXZKvAipZ70H99isntLr+kfc2sXHXgU6qjYhIYvBVQCWrnIzWR5z639fX8LWHFuGc0z0pEekyFFAJIJrHc7fuPcQf5q5jwv+8weOLNsW9TiIiXlNAJYBeWelRbVfX7fzXr6j7uYj4nwIqAYwv6MUv/+24qLdPC+hjExH/i+t0G53NzKYAU0aOHOl1VdrFzLjilCGcPboPW3Yf5KszF7a6fUaqAkpE/M9X33TJ2ouvzoCe3ThleH6b26W3EVAvLdvGXbNX4ZwGnxWR5OWrgPKLp6af2ur6DbsOEGxl5PNvP/EBD8xbx9JNe2JdNRGRTqOASkAj+uS0uc1Ti7c0Wl68cTf/+mhro7KDVbUxrZeISGfy1T0ov+iVlcbQ/Cw2lR5scZu5q0u44pQhbCs7xPayCr7ywAIAThl2+BJhZY2GSBKR5KWASkCpgRTeuOXzVNUGGfvjORG3eXXFDgAmznizUfmBqsPDIl336BL+fFUhQQfnje0XvwqLiMSBLvElqNRAClnpqTzxjVNa3CbSA7tlh6obLV/7yBKue3QJH23ZG/M6iojEk68CKhkHi23LaSN78/atkyKuu+Ofy5uV7SqvjLjt+p37Y1ovEZF481VAJXs385YMzsti5c8m85svH8+vv3R8q9u+U7QrYnlbXdNFRBKNvrWSRLf0AF8pHEz/npmtbvfogsjj9Gn0CRFJNvrWSjJNH3/6z9MKotqvpUkPyw5WM+m3c7nvzbUdrJmISGwpoJJMWpPZDX8yZWxU+9381EccrGo+8eFjizaxYdcBfvvqmpjUT0QkVhRQSWbCsLz61z+//FjMjOMHtX3PrSbouOf15q2kKj0rJSIJSs9BJZnUQAob77qYYNCREm5N/d9XT+TCe95u88HcF5dto2dWOl8pHMS81TvJSg9QE1RAiUhiMj8OKFpYWOiWLFnidTU88fclW/jeM8ui3v4bZwzjoXc2APDjS8Zy1tF9GNm37aGWRERixcyWOucKm5UroPzn0QUb+fG/Pj2ifVMM1s+4OLYVEhFpRUsB5at7UH58UPdIXDmxgE/vvIB/fft0zjq6T7v2DTpYu6OcK2e9z71vrKW2lVHTRUTiSS0on6upDTLyjtlHvP89U0/kshMHxrBGIiKNdYkWlDSXGkhhxheP47ITBxzR/kUlGiJJRLyhXnxdwLQJQ5g6fjC7D1SRl51OfnYGs94NdYz44cVj+MVLK1vct3dORmdVU0SkEbWguggz46/XnsI9U0/iS58LXbI7f2w/vnHm8Fb3u++tos6onohIM2pBdUHjBuSy9Ifn0isrHYBJo/vw1uqdEbfd2cLo6CIi8aYWVBeVn5NR/6Dvf517NLnd0vjNl4/nouOOarbt0k27O7t6IiLqxSchzjnMjIrqWk6/601KD1TVr+udk86SH57nYe1ExM/Ui09aZRZqTWWmBVj6o/O4dfLo+nW79ldRUV3rVdVEpItSQElE088czuMNppt/7sOtHtZGRLoiBZRElBpI4fSRveuX735N03GISOdSQEmrLj0h9IDvKcPzPa6JiHQ1vgoojcUXe3UBtXXPQY9rIiJdja8Cyjn3gnNuem5u2xP4SXT69giNJPHB5r16JkpEOpWvAkpi79gBuYzp3wOAN1bu8Lg2ItKVKKCkVSkpxrEDQgF12z8+8bg2ItKVKKCkTdkZh0fEqq7VFPEi0jkUUNKmW84/uv518Z5DHtZERLoSBZS0qUdmGqePDHUz31h6wOPaiEhXoYCSqAzNzwZg0y4FlIh0DgWURKVf90wgNC6fiEhnUEBJVPJzQnNH7dqvZ6FEpHMooCQqvcMB9dTiLRTc9hLvrN3lcY1ExO8UUBKVEX1yGi3/x58XeVQTEekqFFASlaYBBVB2sNqDmohIV6GAkqjUTQ/f0PWPLeHy+9+lqGS/BzUSEb9TQEnUpk0Y3Gh54frdfLRlL99/dplHNRIRP1NASdR++W/H1T+w21B5hS71iUjsKaAkambGY9eewpybz2pUnmLNL/+JiHSUAkraxczonpnaqEwBJSLxkBQBZWbZZrbEzC7xui4C2emNA+pQda1HNRERP4trQJnZLDMrMbPlTconm9lqMysys9uiONT3gafjU0tpr27pgUbLG3YdYOmmPR7VRkT8Kt4tqIeByQ0LzCwA3A9cCIwFppnZWDM7zsxebPLT18zOA1YAJXGuq0QpPbX5P5sv/fE9D2oiIn6W2vYmR845N9/MCpoUTwCKnHPrAczsKeAy59wMoNklPDM7G8gmFGaHzOxl51yzWfPMbDowHWDIkCExPAuJ1g+f+4Sp44dQXlFDVnqAEwb3rF8XDDrWluxnVN+ciM9UiYg05cU9qIHAlgbLxeGyiJxzdzjnbgaeAP4UKZzC2810zhU65wr79OkT0wpLc2/fOolRfRuPLvHYws1ccu87TPvTQi67/91G6371yiou+L/53PdWUWdWU0SSWFJ0kgBwzj3snHvR63pIyOC8LF646YxWt9lfWVP/+sH560N/zlsX13qJiH94EVBbgYZDEgwKl3WYmU0xs5llZWWxOJy0ITMtwF+vndDi+kcXbCQYdI3KdHlPRKLlRUAtBkaZ2TAzSwemAs/H4sDOuRecc9Nzc3NjcTiJwpmj+nDfFSdFXPfrV1bzb394l78vOXxFN7VJQO0+UEVtkxATEYH4dzN/ElgAjDazYjO71jlXA9wIzAFWAk875z6NZz0kvi45fgBz//vsiOs+Li7je88cHqsv0CCgVm7bx8k/f40bHlsa7yqKSBKKdy++aS2Uvwy8HM/3ls5V0Dubq08v4C/vbmx1u137q5g2cyFXnDKEDzaHnp16bcWOTqihiCSbuAZUZzOzKcCUkSNHel2VLumUYfltBhTAgvWlLFhfGv8KiUhSS5pefNHQPShvXTCuHw9+/XM8c8NEr6siIj7gq4ASb5kZF4w7is8N7dXufd9aVcJP/rWcmtrDj7kFg45Z72zg08/UK1OkK1JAScyZGVNOGNCufa5+eDGPLNjE8x9/Vl/2wrLP+NmLK7j49+/EuooikgR8FVB6Dipx3DvtJBb94Bx+cNEx7dpv1/7K+tert5fXv35w3rr6B39//K/l3PHPT2JTURFJWL4KKN2DSiz9emRy+UktjmIVkXPgnON3r67m1Qa9+2bMXsWvX1lFbdDx6IJNPL5oM1U1EUe9EhGf8FVASeLp2z2Tp6afyuh+3aPafs2O/by3rpR73yyiqGR/o3Ufbt5LZc3huacavhYR/1FASdydOjyfOd89i1duPpNhvbNb3fbZD4opO1QdcV1GagqV1YdbTRXVakGJ+JkCSjrNMUf14K3/Ppunrz/cDf2HF49ptt2sdzZE3D8tkMLG0gP1y2pBifibOeefcdAaPKh73dq1a72ujrTixWWfccxR3emTk8kJP3v1iI7x+i2fZ2STKT9EJPmY2VLnXGHTcl+1oNRJInlccvwARvbtTm5WGj+/bNwRHWP51jK27D4Y45qJSKLwVUBJcvr6xAKe/eZEBvbs1q79bv7bR5z567d4dmlxo/Kikv38+Z0NjR76FZHk46ux+CR5fW5oHrNvPpOikv1cNet9yitq2t4p7P/9/WMuO3EAqYHQ71vn3j0PCE3tcdVpBfGoroh0ArWgJGH0yEzj5CG9mPWf4+nbPYOHrmx2SbpFO/dXUl0bZHtZRX3Zym374lFNEekkvmpBaTRzfxhfkMf7d5zbqGzcgB58+lnLgTNxxpvtfp/dB6oImJGbldbufUUk/nwVUM65F4AXCgsLr/O6LhIbH//kfGqDjl5ZaQy7PXZTiNUGHSf//DUANt51ccyOKyKxo0t8ktByu6WRl52OmfHMDRO5/vPDOXZgj6j2LSmvbLGjREX14WeoNOW8SGLyVQtK/K2wII/Cgrz65aqaIM99uJVbn10Wcfs3V5Uw8o7ZzP/eJIbkZzVaV90guCpraslK138FkUSjFpQkrfTUFP59/GB+dMnY+rJIrauzfvMW//PSCuoeSi8qKWfSb+fWr9eQSSKJSb82StK79oxhXH1aAVv3HmJQr24sWF/KFX9a1GibP729gYNVtZw/7iiumvV+o3UNL/eJSOJQC0p8ISXFGJyXhZlx2ojefHvSiGbbPL5oc7NwgsMBVXaoWiNTiCQQXwWUJiyUOlPHD4l624rqII8v2sQJd77Kmb9+q9GkiSLiHV8FlMbikzqD87Ki7j5+qLqWO/65vH55zY7yVrYWkc7iq4ASaeovV4/nzFG9W93mS398r9Gyc7DnQBVPL97CwarIQy4tK97L1/+8iKIShZlIvKiThPjapNF9mTS6L5tLD1LrHHNXl3DnCyta3ae8oobrH1vK+xt2s27Xfm6/sPmcVV99cCGHqmv59uMfMue7Z8Wr+iJdmlpQ0iUMyc9iWO9srj59GO//4JxWt125bR/vb9gNwIPz1lNw20s8umBjo20OhTtWlJRXICLxoYCSLqdvj0xW/Xwy547pG3H9PW80n+zyx//6lKWb9rCzvHEHihSzuNRRRHSJT7qozLQAD101HucclTVBnnx/M3e/uobyypan+ai7V/WFYw4HW+mBKv75YTGnDs+nf2775rMSkdb5asr3OoWFhW7JkiVeV0OS0N2vrub3bxa1e7/eOeks+eF5caiRiP91iSnfRTrqP04dSveM9l9Y2LW/ivKK6jjUSKTr8lULqsF8UNetXdv8PoJINKprg6SYYcB1jy7hjVUlUe/76y8fz7tFu5g2YQhpgRQ+N7RX/bpDVbUs2lDKaSN6k56q3w1F6rTUgvJVQNXRJT6Jlf2VNRz7kzkAXDlxKI8u2HREx5kwLI/eOem8/Ml2vnn2CL4/+RgAdpZXUlJewbgBerhcui4FlMgRWrOjnG5pAQbnhabsOFhVw+srS/jOkx8e8THf+H+fZ0SfHI750WwqqoO8cOMZHDcol02lB3hs4SbOGdOPU4fnx+oURBKaAkokxpxzHZrl9+Lj+/PSsm31y6/fchbn3j2/flkz/UpXoU4SIjFmZrz23bO4+Pj+ABTkZ/H2rZOi3r9hOAGNwgkgqJl+pYvTc1AiHTCqX3fuv+JkfveVWjJSUzAzTh7Skw827+3wsZ9cvJmzRvXhqNxM0gL6XVK6Hl3iE4mxyppanvtwK99/9hPOOroPXz91KLPe2cCC9aX86JKxXHN6AXe/toZ72/m81blj+nH3V09g/c4DvLduF1OOH1B/X0wkmekelAU7cGcAAA95SURBVEgnK91fSc+sdAIpzYdDqg06RvzgyO9f1enTPYMfXjyGwoI89h6sYtyAXBauL2X51jKuOX0Y1cEgaSkpOIhYD5FEoIASSTAL15cydeZCAP74tZPZe6iaP8wtYsvuQzE5fiDF6JOTwVG5mazbuZ9vnj2Ckn2V3H7RMWSkBhptu2t/JQcra8lMT6Fv98yYvL9ItBRQIgmmujbIFX9ayLgBufz00nH15c45Hl+0mbmrSzhlWD5/mFvEnoOxHaXi9Vs+z8i+OUBoqvsT7ny1ft36X15Eilpb0okUUCJJ7N2iXby/YTePLNjIxcf15/FFmzt0vPEFvRicl8Wk0X1Zv/MA//v6mvp1P5kylqsmFvC711Yzqm93JgzLo39uJqaR2yVOFFAiPjJj9koenLcegAW3f4EH5q7jkSMc5SJa1505jHPG9CMvO52j+3WPuE1lTS0pZuw5UEVOZipZ6eooLG3rEgGlsfikK3n5k22M6pvDqHBYlB2sJiUlNDzTg/PW8/B7G+PyvumpKZw5snejMQp/cfmxXHxcf869ex6ZaQFKyisY1CuLmmCQKccP4NbJx7BgXSmzl2/j+s+P4EBlDc8sLeamL4yke2Za/XFeWb6N3jkZ9WMYqtXWNXSJgKqjFpQI/Oi55fx14SbumXoil504kB37KshMDfDTFz5l4vB8jhuUy4X3vF2/ff/cTLaVVdCvRwY79lW2cuT2S00xasIPHqcHUshITamfe2t8QS9+P+0kaoOOM371Vv0+547px0NXFfLRlr30ykrjYFUt/Xpk0isrTcHlMwookS6mNujYvPsgBflZrX6h1wYd28oOMahXFsGgq+8gsXLbPi68521G9c1hbcn+uNf3xME9+WhL2w8498xK45GrJ5CRlsLRfbvz5qoSBudlkdstjf2VNfzv62u45byjGdEnp36fVdv30T+3G7nd0lo5cmSVNbU4F5rkUuJDASUiR2z19nKO6pHJL19eyd+WbAFC974mznjT45odZgYNv87652Zyzpi+vFdUyvpdB+rLv3fBaL49aSQHq2r41uMf0Dsng59eOo6cjFT2VVSzvayi/h5bZU0t5909n7SAMfu/zmLltn0cOzA34jNlew9W0SMzrcUekK9+up3cbmmcokGAm1FAiUiHlZRXMP3RpVx9egGXnTiwvvyPc9fxq1dWRdxnygkDyEhN4ZmlxQCM6d+Dldv2dUp94+XGSSPpmZXGOWP6sXr7PrIzUrlq1vvc9IVR7NhXwVOLt3Dq8DwuPn4AF4ztR0l5JZfc+w7Q+iDAJeUVfP+ZZXxr0kjGF+QBNGrVQuge47zVOzlnTN9mrboVn+2jb48MeudktHkO1bVBUlMs6sula3aU0z83s9E9w1hRQIlI3DnnMDNK91fysxdX8PVTh1IY/qLdsa+Cvt0zMDOWbtrDL15awYeb93LjpJFsK6vgjVU7yMlIpXhP4weVzx/bj1dX7PDidOLmgnH9GNk3h7fX7mJZcRmj+uYQSDFWbS+PuP2Nk0byuYJefP+ZZZSUH74/+MKNZzCibzaZqQF+NWcVD85bz5C8LF65+UwOVdWSn5PBayt2sGt/JdMmDKE26DBgy56DTJ25kBMG9eTK04aydOMeAgHj0fc28Y9vnUb3zFRqg47aoONbj3/AhGF53PtmEWP79+AHF43h9ZU7+MFFY2I28aYCSkQSinOO7fsqOKpH42esfv7iCqprg9x56Ticg5QU467Zq3hg3jogNHHke+tKKQrfF7vm9GEs3ribT7aWAaFR5TeWHmz0XhMK8nh/4+5OOrPE1DMrjb0xfOA7JyOVF286g6Ft3OOMhgJKRJKWc46NpQcZ3KsbqeGR3Suqa1vsuPDB5j3sPVhFr6x0ThrSq9FxqmqD/PT5T3lr1U4evmY83TPTGNizGzW1QX758ipmvbuhfvufX34sr63YwYeb9tT3Ovz6qUOZvXwbFdVBThrSk7NH9+VfH21lWXFZHP8GEteJg3vy12sndOjSnwJKRCQKW/ceYsnG3SwrLuMHF42p7xCxdkc563cd4IJxR0Xc70BlDef/73wOVdfy9xsmcu8ba3nuo8/q1/frkcFL3zmTC+95m53l0Xfj/8vV47n6L4ublaenplBVE2zn2cXHBz86j7zs9CPeXwElItLJFqwrZcW2fVx9WgFmoQePq2qCpBiUV9Tw4Pz1fLxlL3deFhqLMSM1hc/2VnDDY0sxg4evnsBxA3P57t8+4uh+ORzdrzvT/7oUgCeuO4XtZRUEHcx6ZwMrmnQ8ueOiMfx96RYmH9ufZcV7WbCulIkj8pm7emej7V686QwALrn3HbLTA9w6+RiOys3k+vD7TJswhCffb31orY7O/qyAEhHxgcXh1t01pxfU3/txzvFZWQUDe3bjkfc2Unqgiu+eOyrivaG31+5k0frdXHRcfzbvPsjkYyO3CFdt38ew3tlkpAbYuvcQ6YEU8rLTWbOjnECKMXd1Cfe9WcTsm89iYM9uHTonBZSIiCSklgJK80iLiEhCUkCJiEhCUkCJiEhCUkCJiEhCUkCJiEhCUkCJiEhCSviAMrOzzextM3vAzM72uj4iItI54hpQZjbLzErMbHmT8slmttrMiszstjYO44D9QCZQHK+6iohIYkmN8/EfBu4DHq0rMLMAcD9wHqHAWWxmzwMBYEaT/a8B3nbOzTOzfsDdwNfiXGcREUkAcQ0o59x8MytoUjwBKHLOrQcws6eAy5xzM4BLWjncHqDFWbjMbDowHWDIkCEdqLWIiCQCL+5BDQS2NFguDpdFZGZfNLMHgb8Sao1F5Jyb6ZwrdM4V9unTJ2aVFRERb8T7El+HOef+AfzD63qIiEjn8iKgtgKDGywPCpfFzNKlS3eZ2aYOHKI3sCtW9UlAfj4/nVvy8vP56dxaNzRSoRcBtRgYZWbDCAXTVOCKWL6Bc65D1/jMbEmkkXX9ws/np3NLXn4+P53bkYl3N/MngQXAaDMrNrNrnXM1wI3AHGAl8LRz7tN41kNERJJPvHvxTWuh/GXg5Xi+t4iIJLeEH0nCIzO9rkCc+fn8dG7Jy8/np3M7Ar6cUVdERJKfWlAiIpKQFFAiIpKQFFBNtHMg24RjZoPN7C0zW2Fmn5rZf4XL88zsNTNbG/6zV7jczOz34fNdZmYne3sGbTOzgJl9aGYvhpeHmdmi8Dn8zczSw+UZ4eWi8PoCL+sdDTPraWbPmNkqM1tpZhP98tmZ2XfD/yaXm9mTZpaZzJ9dpMGwj+SzMrOrwtuvNbOrvDiXplo4t9+E/10uM7N/mlnPButuD5/bajO7oEF5x75PnXP6Cf8QGrB2HTAcSAc+BsZ6Xa92nkN/4OTw6+7AGmAs8GvgtnD5bcCvwq8vAmYDBpwKLPL6HKI4x1uAJ4AXw8tPA1PDrx8Avhl+/S3ggfDrqcDfvK57FOf2CPCN8Ot0oKcfPjtCw5ltALo1+Mz+M5k/O+As4GRgeYOydn1WQB6wPvxnr/DrXgl6bucDqeHXv2pwbmPD35UZwLDwd2ggFt+nnn/IifQDTATmNFi+Hbjd63p18Jz+RWjk+NVA/3BZf2B1+PWDwLQG29dvl4g/hEYeeQP4AvBi+D/8rgb/ceo/Q0LP2k0Mv04Nb2den0Mr55Yb/hK3JuVJ/9lxeAzOvPBn8SJwQbJ/dkBBky/xdn1WwDTgwQbljbZLpHNrsu7fgMfDrxt9T9Z9drH4PtUlvsbaNZBtogtfFjkJWAT0c85tC6/aDvQLv062c/4/4FYgGF7OB/a60APg0Lj+9ecWXl8W3j5RDQN2An8JX8J8yMyy8cFn55zbCvwW2AxsI/RZLMU/n12d9n5WSfMZNnENoRYhxPHcFFA+ZWY5wLPAzc65fQ3XudCvM0n3fIGZXQKUOOeWel2XOEkldFnlj865k4ADhC4T1Uviz64XcBmhEB4AZAOTPa1UnCXrZ9UWM7sDqAEej/d7KaAai/tAtp3BzNIIhdPjLjQaPMAOM+sfXt8fKAmXJ9M5nw5camYbgacIXea7B+hpZnWjojSsf/25hdfnAqWdWeF2KgaKnXOLwsvPEAosP3x25wIbnHM7nXPVhGYoOB3/fHZ12vtZJdNniJn9J6F5+74WDmCI47kpoBqrH8g23JtoKvC8x3VqFzMz4M/ASufc3Q1WPQ/U9RC6itC9qbryK8O9jE4FyhpcokgozrnbnXODnHMFhD6bN51zXwPeAr4c3qzpudWd85fD2yfsb7TOue3AFjMbHS46B1iBDz47Qpf2TjWzrPC/0bpz88Vn10B7P6s5wPlm1ivcyjw/XJZwzGwyocvrlzrnDjZY9TwwNdzzchgwCnifWHyfen0jLtF+CPW2WUOo98kdXtfnCOp/BqHLCsuAj8I/FxG6fv8GsBZ4HcgLb2/A/eHz/QQo9PocojzPsznci294+D9EEfB3ICNcnhleLgqvH+51vaM4rxOBJeHP7zlCPbt88dkBdwKrgOWEJiDNSObPDniS0P20akKt32uP5LMidD+nKPxztdfn1cq5FRG6p1T3vfJAg+3vCJ/bauDCBuUd+j7VUEciIpKQdIlPREQSkgJKREQSkgJKREQSkgJKREQSkgJKREQSkgJKJE7MbH/4zwIzuyLGx/5Bk+X3Ynl8kUSggBKJvwKgXQHVYHSFljQKKOfcae2sk0jCU0CJxN9dwJlm9lF4TqRAeG6dxeG5da4HMLOzzextM3ue0CgLmNlzZrY0PI/S9HDZXUC38PEeD5fVtdYsfOzlZvaJmX21wbHn2uG5ph4Pj+ggkrDa+i1NRDruNuC/nXOXAISDpsw5N97MMoB3zezV8LYnA8c65zaEl69xzu02s27AYjN71jl3m5nd6Jw7McJ7fZHQaBQnAL3D+8wPrzsJGAd8BrxLaCy8d2J/uiKxoRaUSOc7n9C4bB8Rmgoln9D4ZQDvNwgngO+Y2cfAQkIDb46idWcATzrnap1zO4B5wPgGxy52zgUJDVVTEJOzEYkTtaBEOp8BNznnGg0KamZnE5pio+HyuYQm7jtoZnMJjVF3pCobvK5F//8lwakFJRJ/5UD3BstzgG+Gp0XBzI4OT0zYVC6wJxxOxxCaKrxOdd3+TbwNfDV8n6sPoam734/JWYh0Mv0GJRJ/y4Da8KW6hwnNYVUAfBDuqLATuDzCfq8AN5jZSkKjRC9ssG4msMzMPnChKUfq/JPQVNsfExrV/lbn3PZwwIkkFY1mLiIiCUmX+EREJCEpoEREJCEpoEREJCEpoEREJCEpoEREJCEpoEREJCEpoEREJCH9f5kn943+fwD5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "865O-1F49oIm",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "f322ad83-50e1-43c5-bc6a-58b3b2a72f9e"
   },
   "source": [
    "# Generate one test sample\n",
    "key = random.PRNGKey(12345)\n",
    "P_test = 100\n",
    "Nx = m\n",
    "u_test, y_test, s_test = generate_test_data(key, 1, P_test)\n",
    "\n",
    "# Predict\n",
    "params = model.get_params(model.opt_state)\n",
    "s_pred = model.predict_s(params, u_test, y_test)\n",
    "\n",
    "# Generate an uniform mesh\n",
    "x = np.linspace(0, 1, Nx)\n",
    "t = np.linspace(0, 1, Nt)\n",
    "XX, TT = np.meshgrid(x, t)\n",
    "\n",
    "# Grid data\n",
    "S_pred = griddata(y_test, s_pred.flatten(), (XX,TT), method='cubic')\n",
    "S_test = griddata(y_test, s_test.flatten(), (XX,TT), method='cubic')\n",
    "\n",
    "# Compute the relative l2 error \n",
    "error = np.linalg.norm(S_pred - S_test, 2) / np.linalg.norm(S_test, 2) \n",
    "print('Relative l2 errpr: {:.3e}'.format(error))"
   ],
   "execution_count": 12,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "Relative l2 errpr: 8.385e-03\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "id": "662sBR7X-I9x",
    "outputId": "c96c3462-eb3d-4672-ef8e-3fbcc2d81b0e"
   },
   "source": [
    "# Plot\n",
    "fig = plt.figure(figsize=(18,5))\n",
    "plt.subplot(1,3,1)\n",
    "plt.pcolor(XX,TT, S_test, cmap='seismic')\n",
    "plt.colorbar()\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Exact $s(x,t)$')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,2)\n",
    "plt.pcolor(XX,TT, S_pred, cmap='seismic')\n",
    "plt.colorbar()\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Predict $s(x,t)$')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,3)\n",
    "plt.pcolor(XX,TT, S_pred - S_test, cmap='seismic')\n",
    "plt.colorbar()\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Absolute error')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 13,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "2nhr_hOJXPh9"
   },
   "source": [],
   "execution_count": 13,
   "outputs": []
  }
 ]
}
